SherbyNet - /page/wikibook/entry.mu

Micron Document

`:top

`!JavaScript`! est un `F33f`_`[langage de programmation`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Langage_de_programmation]`_`f de `F33f`_`[scripts`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Langage_de_script]`_`f principalement employé dans les `F33f`_`[pages web`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Page_web]`_`f interactives et à ce titre est une partie essentielle des `F33f`_`[applications web`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Application_web]`_`f. Avec les langages `F33f`_`[HTML`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Hypertext_Markup_Language]`_`f et `F33f`_`[CSS`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Feuilles_de_style_en_cascade]`_`f, JavaScript est au cœur des langages utilisés par les `F33f`_`[développeurs web`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Développeur_web]`_`f`:cite-ref-4[`F5bf`_`[4`#cite-note-4]`_`f]. Une grande majorité des `F33f`_`[sites web`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Site_web]`_`f l'utilisent`:cite-ref-deployedstats-5-0[`F5bf`_`[5`#cite-note-deployedstats-5]`_`f] et la majorité des `F33f`_`[navigateurs web`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Navigateur_web]`_`f disposent d'un `F33f`_`[moteur JavaScript`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Moteur_JavaScript]`_`f`:cite-ref-6[`F5bf`_`[6`#cite-note-6]`_`f] pour l'`F33f`_`[interpréter`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Interprète_(informatique)]`_`f.

JavaScript est aussi employé pour les `F33f`_`[serveurs Web`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Serveurs_Web]`_`f`:cite-ref-7[`F5bf`_`[7`#cite-note-7]`_`f] avec l'utilisation (par exemple) de `F33f`_`[Node.js`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Node.js]`_`f`:cite-ref-8[`F5bf`_`[8`#cite-note-8]`_`f] ou de `F33f`_`[Deno`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Deno_(logiciel)]`_`f`:cite-ref-9[`F5bf`_`[9`#cite-note-9]`_`f].

JavaScript a été créé en 1995 par `F33f`_`[Brendan Eich`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Brendan_Eich]`_`f et intégré au `F33f`_`[navigateur web`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Navigateur_web]`_`f `F33f`_`[Netscape Navigator`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Netscape_Navigator]`_`f 2.0. L'implémentation concurrente de JavaScript par `F33f`_`[Microsoft`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Microsoft]`_`f dans `F33f`_`[Internet Explorer`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Internet_Explorer]`_`f, jusqu'à sa version 9, se nommait `F33f`_`[JScript`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=JScript]`_`f, tandis que celle d'`F33f`_`[Adobe Systems`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Adobe_Systems]`_`f se nommait `F33f`_`[ActionScript`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=ActionScript]`_`f. JavaScript a été standardisé sous le nom d'`F33f`_`[ECMAScript`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=ECMAScript]`_`f en juin 1997 par `F33f`_`[Ecma International`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Ecma_International]`_`f dans le standard ECMA-262. La version en vigueur de ce standard depuis juin 2022 est la 13e édition.

C'est un langage `F33f`_`[orienté objet`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Orienté_objet]`_`f à `F33f`_`[prototype`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Programmation_orientée_prototype]`_`f : les bases du langage et ses principales `F33f`_`[interfaces`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Interface_de_programmation]`_`f sont fournies par des `F33f`_`[objets`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Objet_(informatique)]`_`f. Cependant, à la différence d'un langage orienté objets à classes, les objets de base ne sont pas des `F33f`_`[instances`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Instance_(programmation)]`_`f de `F33f`_`[classes`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Classe_(informatique)]`_`f. En outre, les `F33f`_`[fonctions`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Routine_(informatique)]`_`f sont des `F33f`_`[objets de première classe`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Objet_de_première_classe]`_`f. Le langage supporte le `F33f`_`[paradigme`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Paradigme_de_programmation]`_`f `F33f`_`[objet`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Programmation_objet]`_`f, `F33f`_`[impératif`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Programmation_impérative]`_`f et `F33f`_`[fonctionnel`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Programmation_fonctionnelle]`_`f.

JavaScript est le langage possédant le plus large écosystème grâce à son gestionnaire de dépendances `F33f`_`[npm`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Npm]`_`f, avec plus de deux millions de paquets en septembre 2022`:cite-ref-10[`F5bf`_`[10`#cite-note-10]`_`f].

>>Contents

• `F0af`_`[Histoire`#histoire]`_`f

• `F0af`_`[Début`#d-but]`_`f

• `F0af`_`[Marque déposée`#marque-d-pos-e]`_`f

• `F0af`_`[Standardisation`#standardisation]`_`f

• `F0af`_`[Sécurité`#s-curit]`_`f

• `F0af`_`[Concepts de programmation`#concepts-de-programmation]`_`f

• `F0af`_`[Hello world`#hello-world]`_`f

• `F0af`_`[Utilisation`#utilisation]`_`f

• `F0af`_`[Dans une page web`#dans-une-page-web]`_`f

• `F0af`_`[Autres utilisations`#autres-utilisations]`_`f

• `F0af`_`[Particularités du langage`#particularit-s-du-langage]`_`f

• `F0af`_`[Liaison des identifiants`#liaison-des-identifiants]`_`f

• `F0af`_`[Portée lexicale des variables`#port-e-lexicale-des-variables]`_`f

• `F0af`_`[Déclaration des variables`#d-claration-des-variables]`_`f

• `F0af`_`[Variables globales`#variables-globales]`_`f

• `F0af`_`[Fonctions anonymes`#fonctions-anonymes]`_`f

• `F0af`_`[Fermetures lexicales`#fermetures-lexicales]`_`f

• `F0af`_`[Expressions de fonctions immédiatement invoquées`#expressions-de-fonctions-imm-diatement-invoqu-es]`_`f

• `F0af`_`[Prototypes`#prototypes]`_`f

• `F0af`_`[Séparation des instructions`#s-paration-des-instructions]`_`f

• `F0af`_`[Annexes`#annexes]`_`f

• `F0af`_`[Articles connexes`#articles-connexes]`_`f

• `F0af`_`[Liens externes`#liens-externes]`_`f

• `F0af`_`[Notes et références`#notes-et-r-f-rences]`_`f

-─

>>Histoire

>>>Début

Le langage a été créé en dix jours, en mai `F33f`_`[1995`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=1995]`_`f, pour le compte de la `F33f`_`[Netscape Communications Corporation`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Netscape_Communications_Corporation]`_`f par `F33f`_`[Brendan Eich`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Brendan_Eich]`_`f. Il s'est inspiré de nombreux langages, notamment de `F33f`_`[Java`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Java_(langage)]`_`f, en simplifiant la `F33f`_`[syntaxe`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Syntaxe_JavaScript]`_`f pour les débutants`:cite-ref-11[`F5bf`_`[11`#cite-note-11]`_`f]. `F33f`_`[Brendan Eich`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Brendan_Eich]`_`f a initialement développé un langage de script côté serveur, appelé LiveScript, pour renforcer l'offre commerciale de `F33f`_`[serveur HTTP`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Serveur_HTTP]`_`f. Netscape travaille alors au développement d'une version orientée client de LiveScript.

Quelques jours avant sa sortie, Netscape change le nom de LiveScript pour JavaScript. `F33f`_`[Sun Microsystems`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Sun_Microsystems]`_`f et Netscape étaient partenaires, et la `F33f`_`[machine virtuelle`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Machine_virtuelle]`_`f `F33f`_`[Java`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Java_(langage)]`_`f de plus en plus populaire. Ce changement de nom servait les intérêts des deux sociétés. Le 4 décembre 1995 `F33f`_`[Netscape`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Netscape_Communications]`_`f et `F33f`_`[Sun Microsystems`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Sun_Microsystems]`_`f annoncent`:cite-ref-newsrelease67-12-0[`F5bf`_`[12`#cite-note-newsrelease67-12]`_`f] la sortie de JavaScript, décrit comme un complément à `F33f`_`[Java`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Java_(langage)]`_`f, dans un `F33f`_`[communiqué de presse`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Communiqué_de_presse]`_`f commun. Cette initiative a contribué à créer auprès du public une certaine confusion entre les deux langages, proches syntaxiquement mais pas du tout dans leurs concepts fondamentaux, et qui perdure encore de nos jours.

En mars 1996, Netscape met en œuvre le `F33f`_`[moteur JavaScript`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Moteur_JavaScript]`_`f dans son `F33f`_`[navigateur web`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Navigateur_web]`_`f `F33f`_`[Netscape Navigator`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Netscape_Navigator]`_`f 2.0. Le succès de ce navigateur contribue à l'adoption rapide de JavaScript dans le développement web orienté client. `F33f`_`[Microsoft`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Microsoft]`_`f réagit alors en développant `F33f`_`[JScript`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=JScript]`_`f, qu'il inclut ensuite dans `F33f`_`[Internet Explorer`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Internet_Explorer]`_`f 3.0 en août 1996 pour la sortie de son navigateur.

« JavaScript » devient une `F33f`_`[marque déposée`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Marque_déposée]`_`f par `F33f`_`[Sun Microsystems`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Sun_Microsystems]`_`f aux `F33f`_`[États-Unis`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=États-Unis]`_`f en mai 1997`:cite-ref-13[`F5bf`_`[13`#cite-note-13]`_`f]`:cite-ref-14[`F5bf`_`[14`#cite-note-14]`_`f].

>>Marque déposée

"JavaScript" est une `F33f`_`[marque déposée`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Marque_déposée]`_`f d'`F33f`_`[Oracle Corporation`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Oracle_Corporation]`_`f aux États-Unis`:cite-ref-15[`F5bf`_`[15`#cite-note-15]`_`f]`:cite-ref-16[`F5bf`_`[16`#cite-note-16]`_`f]. À l'origine, la marque a été attribuée à `F33f`_`[Sun Microsystems`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Sun_Microsystems]`_`f le 6 mai 1997, puis transférée à Oracle lors de leur acquisition de Sun en 2009`:cite-ref-17[`F5bf`_`[17`#cite-note-17]`_`f]`:cite-ref-18[`F5bf`_`[18`#cite-note-18]`_`f]`:cite-ref-19[`F5bf`_`[19`#cite-note-19]`_`f].

>>>Standardisation

Netscape soumet alors JavaScript à `F33f`_`[Ecma International`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Ecma_International]`_`f pour standardisation.

>>>>Version 1 : Naissance du standard ECMA-262

Les travaux débutent en novembre 1996 et se terminent en juin 1997, donnant naissance à la 1re édition du standard ECMA-262 qui spécifie le langage `F33f`_`[ECMAScript`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=ECMAScript]`_`f d'où le fait que le n° ou l'année de la version est souvent précédée par `*ECMAScript`* ou en abrégé `*ES`*. Le standard est ensuite soumis à l'`F33f`_`[ISO/CEI`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Organisation_internationale_de_normalisation]`_`f et publié en avril 1998 en tant que standard international ISO/CEI 16262.

>>>>Version 2 : Homogénéisation avec le standard ISO/CEI 16262

Des changements rédactionnels sont apportés au standard ECMA-262 pour le conformer au standard international ISO/CEI 16262, aboutissant à la 2e édition du standard ECMA-262 en juin 1998.

>>>>Version 3 : Améliorations et constitution du langage

La 3e édition du standard ECMA-262 introduit :

• des `F33f`_`[expressions rationnelles`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Expression_régulière]`_`f plus puissantes ;

• une amélioration de la manipulation des `F33f`_`[chaînes de caractères`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Chaîne_de_caractères]`_`f ;

• de nouvelles instructions de contrôle ;

• une gestion des exceptions avec les instructions try/catch ;

• le formatage des nombres.

Elle est publiée par Ecma International en décembre 1999 puis soumise à l'ISO/CEI qui publie le standard international ISO/CEI 16262:2002 en juin 2002. Après la publication de la 3e édition s'ensuit une adoption massive par tous les navigateurs Web.

>>>>Version 4 : L'étape inachevée

Un travail important est entrepris pour développer la 4e édition du standard ECMA-262, mais il ne sera pas achevé et cette édition ne verra jamais le jour. Cependant une partie du développement effectué sera intégrée à la 6e édition.

>>>>Version 5 : Désambiguïsation et nouvelles fonctionnalités

La 5e édition du standard ECMA-262 clarifie les ambiguïtés de la 3e édition et introduit les accesseurs, l'introspection, le contrôle des attributs, des fonctions de manipulation de tableaux supplémentaires, le support du format `F33f`_`[JSON`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=JavaScript_Object_Notation]`_`f et un mode strict pour la vérification des erreurs. Elle est publiée par Ecma International en décembre 2009 puis soumise à l'ISO/CEI qui apporte des corrections mineures et publie le standard international ISO/CEI 16262:2011 en juin 2011. L'édition 5.1 du standard ECMA-262 reprenant à l'identique le texte du standard international ISO/CEI 16262:2011 est publiée à la même date.

>>>>Version 6 (ES6) - ECMAScript 2015 : Amélioration du support et des fonctionnalités

Bien que le développement de la 6e édition du standard ECMA-262 ait commencé officiellement en 2009, peu avant la publication de la 5e édition, sa publication en juin 2015 est en réalité l'aboutissement de 15 ans de travail depuis la publication de la 3e édition en 1999. Le but de cette 6e édition est d'apporter un meilleur support pour les applications d'envergure, la création de bibliothèques et l'utilisation d'ECMAScript comme cible de `F33f`_`[compilation`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Compilateur]`_`f pour d'autres langages. Cette édition introduit notamment les modules, les classes, la portée lexicale au niveau des blocs, les itérateurs et les générateurs, les promesses pour la programmation asynchrone, les patrons de déstructuration, l'optimisation des appels terminaux, de nouvelles `F33f`_`[structures de données`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Structure_de_données]`_`f (`F33f`_`[tableaux associatifs`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Tableau_associatif]`_`f, `F33f`_`[ensembles`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Ensemble]`_`f, tableaux binaires), le support de caractères `F33f`_`[Unicode`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Unicode]`_`f supplémentaires dans les chaînes de caractères et les expressions rationnelles et la possibilité d'étendre les structures de données prédéfinies. À partir de cette version, l'intitulé officiel de la version est ECMAScript 2015 (année de parution)`:cite-ref-20[`F5bf`_`[20`#cite-note-20]`_`f].

>>>>Version 7 - ECMAScript 2016 : une adaptation permanente aux outils du web

La 7e édition du standard ECMA-262 est la première édition issue du nouveau processus de développement ouvert et du rythme de publication annuel adoptés par le comité Ecma TC39. Un document au format texte est créé à partir de la 6e édition et est mis en ligne sur `F33f`_`[GitHub`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=GitHub]`_`f comme base de développement pour cette nouvelle édition. Après la correction de milliers de bugs et d'erreurs rédactionnelles ainsi que l'introduction de l'opérateur d'exponentiation et d'une nouvelle méthode pour les prototypes de tableaux, la 7e édition est publiée en juin 2016.

>>>>Version 8 (ES8) - ECMAScript 2017: Asynchronicité

L'apport majeur concerne les `F33f`_`[fonctions asynchrones`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Système_asynchrone]`_`f.

On retrouve également :

• Le partage de mémoire entre différents fil d'exécution et workers (Shared memory and atomics)

• Les fonctions `B100`F9d9Object.values()`f`b et `B100`F9d9Object.entries()`f`b qui permettent de faciliter la manipulation des objets.

L'édition actuelle du standard ECMA-262 est la 13e édition publiée en juin 2022`:cite-ref-21[`F5bf`_`[21`#cite-note-21]`_`f].

>>Sécurité

JavaScript et la structure `F33f`_`[DOM`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Document_Object_Model]`_`f des pages `F33f`_`[HTML`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Hypertext_Markup_Language]`_`f/`F33f`_`[XML`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Extensible_Markup_Language]`_`f ont quelques `F33f`_`[failles de sécurité`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Vulnérabilité_(informatique)]`_`f. En effet, des `F33f`_`[scripts`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Programme_informatique]`_`f malveillants peuvent se cacher dans le code d'une page web et s'exécuter sur l'ordinateur cible de l'utilisateur du Web.

Les problèmes de sécurité étaient souvent présents avec `F33f`_`[ActiveX`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=ActiveX]`_`f, une fonctionnalité du navigateur maintenant obsolète `F33f`_`[Internet Explorer`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Internet_Explorer]`_`f. Cette fonctionnalité permettait l'exécution de programmes malveillants sur l'ordinateur de la victime, en dehors du navigateur. Aujourd'hui, l'environnement javascript est plus sécurisé.

Les fournisseurs de `F33f`_`[navigateurs web`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Navigateur_web]`_`f tentent de réduire ce risque avec deux restrictions :

• l'une est de faire exécuter ces scripts dans un espace à part des autres données (`F33f`_`[sandbox`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Sandbox_(sécurité_informatique)]`_`f) dans lequel seules des actions relatives au web (mouvements de souris, affichage de `F33f`_`[pixel`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Pixel]`_`f, communications) peuvent être exécutées, sans avoir accès au `F33f`_`[système de fichier`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Système_de_fichiers]`_`f principal ;

• la deuxième est de n'exécuter les scripts que selon les contraintes de `F33f`_`[same-origin policy`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Same-origin_policy]`_`f : dans cet esprit, un site Web ne doit pas avoir accès aux informations telles que les noms d'utilisateur et mot de passe ou `F33f`_`[cookies`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Cookie_(informatique)]`_`f reçus des autres sites visités.

Les vulnérabilités de JavaScript sont bien souvent des brèches d'au moins l'un de ces deux principes.

Certains sous-ensembles du langage Javascript tels que JavaScript—ADsafe ou Secure ECMAScript (SES) fournissent de plus grands niveaux de sécurité, en particulier pour les scripts créés par des tierces parties (notamment les publicités)`:cite-ref-22[`F5bf`_`[22`#cite-note-22]`_`f]`:cite-ref-23[`F5bf`_`[23`#cite-note-23]`_`f]. Caja est un autre logiciel pour inclure et isoler de manière sécurisée du JavaScript et du HTML tierce partie.

La `F33f`_`[Politique de sécurité du contenu`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Content_Security_Policy]`_`f est la principale méthode destinée à assurer que seul un script de confiance est exécuté sur une page Web. `F33f`_`[Meltdown`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Meltdown_(vulnérabilité)]`_`f est une vulnérabilité indépendante de Javascript, qui peut notamment être exploitée en Javascript.

>>Concepts de programmation

Le propos de JavaScript est de manipuler de façon simple des `F33f`_`[objets`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Programmation_orientée_objet]`_`f, au sens informatique, fournis par une application hôte. Par exemple dans un navigateur web, un script écrit en javascript peut être utilisé pour apporter une touche interactive ou dynamique à un applicatif (page ou site web), qui sans cela serait une page statique figée. Le langage Javascript permet par exemple d'écrire des scripts pour afficher ou cacher un paragraphe, une image ou un `F33f`_`[popup`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Pop-up]`_`f, selon les interactions de l'utilisateur, ou d'informer le serveur du temps passé à lire une page.

>>>Hello world

Il est possible dans un script en langage Javascript, d'afficher le texte `*`F33f`_`[hello world`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Hello_world]`_`f`* sur la console de debug de l’application. Ceci peut être utilisé par des développeurs en phase de mise au point`:cite-ref-24[`F5bf`_`[24`#cite-note-24]`_`f]. :

`B100`F9d9window.console.log('Hello world'); window.console.exp(hello world)`f`b

`B100`F9d9// ou`f`b

`B100`F9d9global.console.log('Hello world'); window.console.log(hello world)`f`b

Dans une application hôte d'un navigateur, `*console`* est une des méthodes de l'objet global `*window`*`:cite-ref-25[`F5bf`_`[25`#cite-note-25]`_`f]`*.`* Dans d'autres applications hôtes comme `F33f`_`[Node.js`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Node.js]`_`f, l'objet global est `*global`*`:cite-ref-26[`F5bf`_`[26`#cite-note-26]`_`f]. Les méthodes de l'objet global étant accessibles sans préfixe, `*window`* et `*global`* sont facultatifs.

La syntaxe

`B100`F9d9console.log('Hello world');`f`b

aura donc exactement le même résultat en plus d'être compatible sur tous les environnements.

>>Utilisation

Le code JavaScript a besoin d'un `*objet global`* pour y rattacher les `F33f`_`[déclarations`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Déclaration_(informatique)]`_`f (`F33f`_`[variables`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Variable_(informatique)]`_`f et `F33f`_`[fonctions)`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Routine_(informatique)]`_`f avant d'exécuter des instructions. La situation la plus connue est celle de l'objet `*window`* obtenu dans le contexte d'une `F33f`_`[page web`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Page_web]`_`f. D'autres environnements sont possibles dont celui fourni par `F33f`_`[Adobe`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Adobe_(entreprise)]`_`f ou l'environnement `F33f`_`[Node.js`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Node.js]`_`f (voir plus bas Autres utilisations).

Les principaux domaines d'application de JavaScript sont avant tout la programmation, les activités de programmation de base et tout ce qui est lié à l'informatique.

>>>Dans une page web

Du code JavaScript peut être intégré directement au sein des `F33f`_`[pages web`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Page_web]`_`f, pour y être exécuté sur le poste `F33f`_`[client`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Client-serveur]`_`f. C'est alors le `F33f`_`[navigateur web`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Navigateur_web]`_`f qui prend en charge l'exécution de ces programmes appelés scripts.

Généralement, JavaScript sert à contrôler les données saisies dans des formulaires `F33f`_`[HTML`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Hypertext_Markup_Language]`_`f, ou à interagir avec le document HTML `*via`* l'interface `F33f`_`[Document Object Model`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Document_Object_Model]`_`f, fournie par le navigateur (on parle alors parfois de `F33f`_`[HTML dynamique`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=HTML_dynamique]`_`f ou DHTML). Il est aussi utilisé pour réaliser des applications dynamiques, des transitions, des animations ou manipuler des données réactives, à des fins ergonomiques ou cosmétiques.

JavaScript n'est pas limité à la manipulation de documents HTML et peut aussi servir à manipuler des documents `F33f`_`[SVG`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=SVG]`_`f, `F33f`_`[XUL`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=XUL]`_`f et autres `F33f`_`[dialectes XML`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Extensible_Markup_Language]`_`f.

>>>>Intégration

Il existe plusieurs façons d’intégrer JavaScript dans du code html:

• Dans des attributs d’évènements html : `B100`F9d9<button onclick="alert('clic !')">clic ici</button>`f`b. Le code JavaScript `B100`F9d9alert('clic !')`f`bsera exécuté quand le bouton sera cliqué.

• Dans des balises <script> : `B100`F9d9<script>//ici on peut mettre du code JavaScript</script>`f`b

• Dans des fichiers externes : `B100`F9d9<script src="chemin/ver/mon/fichier.js"></script>`f`b

>>>>Incompatibilité

Netscape et Microsoft (avec `F33f`_`[JScript`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=JScript]`_`f dans `F33f`_`[Internet Explorer`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Internet_Explorer]`_`f jusqu'à la version 9) ont développé leur propre variante de ce langage qui chacune supporte presque intégralement la norme ECMAScript mais possède des fonctionnalités supplémentaires et incompatibles, rarement utilisées dans le cadre de la programmation de pages web. Pourtant les scripts JavaScript sont souvent la source de difficultés. Elles sont plus souvent dues à la prise en charge des différentes versions des modèles d'objets (`F33f`_`[DOM`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Document_Object_Model]`_`f) fournis par les navigateurs, qu'à des problèmes de `F33f`_`[portabilité`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Portabilité_(informatique)]`_`f du langage (les différentes mises en œuvre respectant relativement bien la norme ECMAScript).

Pour vérifier dynamiquement si un objet (dans la version JavaScript utilisée lors de l'interprétation) possède bien une méthode, on utilise souvent une construction du type :

`B100`F9d9if (monObjet.methode && typeof monObjet.methode === 'function') {`f`b

`B100`F9d9 monObjet.methode();`f`b

`B100`F9d9}`f`b

On vérifie ainsi que `*monObjet`* a bien une mise en œuvre de `*methode`* que l'on peut alors utiliser. Le plus souvent, si un navigateur ne gère pas la `*methode`* de `*monObjet`*, il gère une méthode comparable `*methode2`*, et on peut alors adapter le code JavaScript au navigateur qui l'exécute :

`B100`F9d9if (typeof monObjet.methode === 'function') {`f`b

`B100`F9d9 monObjet.methode();`f`b

`B100`F9d9} else if (typeof monObjet.methode2 === 'function') {`f`b

`B100`F9d9 monObjet.methode2();`f`b

`B100`F9d9}`f`b

Une autre méthode consiste à vérifier, côté serveur, le navigateur utilisé par le client et d'envoyer le code correspondant. Cela n'est toutefois pas recommandable, car il est largement préférable de tester directement l'existence, le comportement d'une fonction, d'une propriété, etc. plutôt que de faire des présomptions basées sur la détection du navigateur.

>>>>Ajax

`F33f`_`[Ajax`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Ajax_(informatique)]`_`f (de l'anglais `*Asynchronous JavaScript And XML`*) est un ensemble de techniques découplant l'échange de données entre le navigateur et le serveur web de l'affichage d'une page web, ce qui permet de modifier le contenu des pages web sans les recharger. Grâce à l'objet JavaScript `F33f`_`[XMLHTTPRequest`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=XMLHttpRequest]`_`f, cette méthode permet d'effectuer des requêtes HTTP sur le serveur web depuis le navigateur web, et permet également de traiter les réponses `F33f`_`[HTTP`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Hypertext_Transfer_Protocol]`_`f du serveur web pour modifier le contenu de la page web. La réponse était en général au format `F33f`_`[XML`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Extensible_Markup_Language]`_`f qui tend aujourd'hui à être remplacé par le format `F33f`_`[JSON`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=JavaScript_Object_Notation]`_`f qui a l'avantage d'être natif en JavaScript. Le script manipule l'ensemble d'objets `F33f`_`[DOM`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Document_Object_Model]`_`f qui représente le contenu de la page web. Les technologies `F33f`_`[XMLHTTPRequest`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=XMLHttpRequest]`_`f, `F33f`_`[XML`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=XML]`_`f et `F33f`_`[DOM`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Document_Object_Model]`_`f ont été ajoutées aux navigateurs web entre 1995 et 2005. La méthode Ajax permet de réaliser des `F33f`_`[applications Internet riches`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Web_2.0]`_`f, offrant une maniabilité et un confort supérieur ; c'est un des sujets phares du mouvement `F33f`_`[Web 2.0`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Web_2.0]`_`f.

>>>>JSON

`F33f`_`[JSON`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=JavaScript_Object_Notation]`_`f (`*JavaScript Object Notation`*) est un format utilisant la notation des objets JavaScript pour transmettre de l'information structurée, d'une façon plus compacte et plus proche des `F33f`_`[langages de programmation`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Langages_de_programmation]`_`f, que XML.

Malgré l'existence du DOM et l'introduction récente de E4X (voir ci-dessous) dans la spécification du langage JavaScript, JSON reste le moyen le plus simple d'accéder à des données, puisque chaque flux JSON n'est rien d'autre qu'un objet JavaScript `F33f`_`[sérialisé`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Sérialisation]`_`f. De plus, malgré son lien historique (et technique) avec JavaScript, JSON reste un `F33f`_`[format de données`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Format_de_données]`_`f structurées, et peut être utilisé facilement par tous les langages de programmation.

Depuis 2009, les navigateurs commencent à intégrer un support natif du format JSON, ce qui facilite sa manipulation, la sécurité (contre l'évaluation de scripts malveillants inclus dans une chaine JSON), et la rapidité de traitement. Ainsi les navigateurs `F33f`_`[Firefox`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Mozilla_Firefox]`_`f et `F33f`_`[IE`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Internet_Explorer]`_`f`:cite-ref-27[`F5bf`_`[27`#cite-note-27]`_`f] l'intègrent respectivement dès les versions 3.5 et 8.

Exemple de JSON :

`B100`F9d9{`f`b

`B100`F9d9 "clef1": "valeur",`f`b

`B100`F9d9 "clef2": 12345,`f`b

`B100`F9d9 "clef3": true,`f`b

`B100`F9d9 "clef4": {`f`b

`B100`F9d9 "clef5": "valeur"`f`b

`B100`F9d9 }`f`b

`B100`F9d9}`f`b

La structure est organisée par clef/valeurs. Les clefs doivent être entre guillemets doubles. Les valeurs peuvent être :

• une string (chaîne de caractères entre guillemets doubles)

• un nombre

• un booléen (true ou false pour vrai ou faux)

• une structure clef/valeur

Un JSON valide ne peut pas comporter de commentaires. Il existe des validateurs de JSON en ligne.

>>>Autres utilisations

>>>>Dans la barre d’adresse d’un navigateur

Taper des adresses comme `B100`F9d9javascript: ducodejavascript`f`b provoque l’exécution de ducodejavascript. Exemple: javascript: alert(document.cookie) provoque l’affichage des cookies de la page.

>>>>Sur un serveur web

JavaScript peut également être utilisé comme langage de programmation sur un `F33f`_`[serveur HTTP`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Serveur_HTTP]`_`f à l'image des langages comme `F33f`_`[PHP`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=PHP]`_`f, `F33f`_`[ASP`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Active_Server_Pages]`_`f, etc. D'ailleurs le projet `F33f`_`[CommonJS`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=CommonJS]`_`f travaille dans le but de spécifier un écosystème pour JavaScript en dehors du navigateur (par exemple sur le serveur ou pour les applications de bureau natives). Le projet a été lancé par Kevin Dangoor en janvier 2009. Le projet CommonJS n'est pas affilié avec le groupe de l'Ecma International TC39 travaillant sur ECMAScript, mais certains membres du TC39 participent au projet.

Historiquement, JavaScript était proposé sur les serveurs de `F33f`_`[Netscape`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Netscape_Communications_Corporation]`_`f, par la suite distribués par `F33f`_`[Sun Microsystems`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Sun_Microsystems]`_`f sous les noms `F33f`_`[iPlanet`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=IPlanet]`_`f et Sun ONE, mais `F33f`_`[JScript`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=JScript]`_`f peut aussi être utilisé sur les serveurs `F33f`_`[Internet Information Services`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Internet_Information_Services]`_`f de `F33f`_`[Microsoft`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Microsoft]`_`f. `F33f`_`[JScript`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=JScript]`_`f peut d'ailleurs servir pour scripter une plate-forme `F33f`_`[Microsoft Windows`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Microsoft_Windows]`_`f via `F33f`_`[Windows Scripting Host`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Windows_Scripting_Host]`_`f (WSH).

Il existe par ailleurs des projets indépendants et `F33f`_`[Open Source`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Open_source]`_`f d'implémentation de serveurs en JavaScript. Parmi eux, on pourra distinguer `F33f`_`[Node.js`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Node.js]`_`f, une plateforme polyvalente de développement d'applications réseau se basant sur le moteur JavaScript V8 et les spécifications `F33f`_`[CommonJS`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=CommonJS]`_`f.

>>>>Autres supports

`F33f`_`[ActionScript`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=ActionScript]`_`f, utilisé dans `F33f`_`[Adobe Flash`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Adobe_Flash]`_`f, est aussi une mise en œuvre d'ECMAScript. Il permet de manipuler tous les éléments de l'animation, considérés comme des objets. JavaScript peut être utilisé pour scripter d'autres applications `F33f`_`[Adobe`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Adobe_Systems]`_`f (`F33f`_`[Photoshop`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Adobe_Photoshop]`_`f, `F33f`_`[Illustrator`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Adobe_Illustrator]`_`f, …), ce qui permet d'avoir des scripts indépendants de la plate-forme (Microsoft Windows, `F33f`_`[Apple`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Apple]`_`f OSX, Linux…).

JavaScript est enfin utilisé dans la plate-forme de développement de `F33f`_`[Mozilla`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Mozilla_Foundation]`_`f, sur laquelle sont basés plusieurs logiciels comme des `F33f`_`[navigateurs Web`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Navigateur_web]`_`f, pour des tâches relatives à l'interface utilisateur et à la communication interne (ex. : les extensions de `F33f`_`[Firefox`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Mozilla_Firefox]`_`f et `F33f`_`[Thunderbird`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Mozilla_Thunderbird]`_`f sont installées à base de fichiers `F33f`_`[XPI`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=XPI]`_`f utilisant le JavaScript. Voir aussi `F33f`_`[Prefs.js`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Prefs.js]`_`f).

Depuis 2004, l'objet `*js`* de l'environnement de programmation graphique `F33f`_`[Max/MSP`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Max/MSP]`_`f permet d'ouvrir une fenêtre pour programmer en JavaScript, au sein même d'un programme `F33f`_`[Max/MSP`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Max/MSP]`_`f.

Les logiciels `F33f`_`[ImageJ`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=ImageJ]`_`f et `F33f`_`[CaRMetal`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=CaRMetal]`_`f sont munis de consoles JavaScript, qui leur permettent d'écrire des scripts dans un contexte graphique. `F33f`_`[Algobox`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Algobox]`_`f utilise JavaScript pour la syntaxe de ses fonctions. `F33f`_`[H5P`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=H5P]`_`f se sert de `F33f`_`[HTML5`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=HTML5]`_`f et Javascript pour faciliter la création de contenus interactifs en ligne.

JavaScript est aussi utilisé dans un contenu `F33f`_`[BIFS`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Binary_Format_for_Scene]`_`f pour l'exploitation des événements. Pour cela la spécification BIFS fournit un nœud Script pour incorporer de l'ECMAScript.

La suite bureautique `F33f`_`[OpenOffice.org`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=OpenOffice.org]`_`f permet d'utiliser JavaScript comme langage de macros.

JavaScript est aussi utilisable en `F33f`_`[shell`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Shell_(informatique)]`_`f`:cite-ref-28[`F5bf`_`[28`#cite-note-28]`_`f] ou avec les gadgets Vista.

Le format graphique vectoriel `F33f`_`[SVG`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=SVG]`_`f incorpore le langage ECMAscript pour créer des graphiques interactifs directement exploitable dans un navigateur.

Enfin, JavaScript est également utilisé pour dynamiser le QML de la bibliothèque graphique `F33f`_`[Qt`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Qt]`_`f.

>>Particularités du langage

>>>Liaison des identifiants

En JavaScript, `*toutes`* les expressions (identifiants, littéraux et opérateurs et leurs opérandes) sont de `F33f`_`[type référence`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Référence_(programmation)]`_`f (comme en `F33f`_`[Python`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Python_(langage)]`_`f et `F33f`_`[Ruby`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Ruby]`_`f, mais à la différence du `F33f`_`[C++`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=C++]`_`f, `F33f`_`[Java`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Java_(langage)]`_`f, `F33f`_`[C#`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=C_sharp]`_`f, `F33f`_`[Swift`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Swift_(langage_d'Apple)]`_`f et `F33f`_`[OCaml`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=OCaml]`_`f qui possèdent aussi des expressions de type valeur), c'est-à-dire que leur évaluation ne produit pas une donnée directement mais une référence vers une donnée. La référence se nomme le `*référent`* de l’expression et la donnée le `*référé`* de l’expression.

En JavaScript, l'`F33f`_`[affectation`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Affectation_(informatique)]`_`f d'une variable modifie son référent, autrement dit, elle lie la variable à une autre donnée : on parle de changement de liaison de la variable (en anglais `*variable rebinding`*).

`B100`F9d9var maVariable1 = 0; // lie \`maVariable1\` à une donnée de valeur 0`f`b

`B100`F9d9var maVariable2 = maVariable1; // lie \`maVariable2\` à la donnée liée à \`maVariable1\``f`b

`B100`F9d9maVariable1++; // équivalent à \`maVariable1 = maVariable1 + 1;\`, relie \`maVariable1\` à une nouvelle donnée de valeur maVariable1 + 1 (affectation) juin`f`b

`B100`F9d9alert(maVariable1); // affiche 1`f`b

`B100`F9d9alert(maVariable2); // affiche 0`f`b

`B100`F9d9`f`b

`B100`F9d9var maVariable3 = [1, 2, 3]; // lie \`maVariable3\` à une donnée de valeur [1, 2, 3]`f`b

`B100`F9d9var maVariable4 = maVariable3; // lie \`maVariable4\` à la donnée liée à \`maVariable3\``f`b

`B100`F9d9maVariable3 = [4, 5, 6]; // relie \`maVariable3\` à une nouvelle donnée de valeur [4, 5, 6] (affectation)`f`b

`B100`F9d9alert(maVariable3); // affiche [4, 5, 6]`f`b

`B100`F9d9alert(maVariable4); // affiche [1, 2, 3]`f`b

`B100`F9d9`f`b

`B100`F9d9var maVariable5 = [1, 2, 3]; // lie \`maVariable5\` à une donnée de valeur [1, 2, 3]`f`b

`B100`F9d9var maVariable6 = maVariable5; // lie \`maVariable6\` à la donnée liée à \`maVariable5\``f`b

`B100`F9d9maVariable5.push(4); // modifie la donnée liée à \`maVariable5\` et \`maVariable6\``f`b

`B100`F9d9alert(maVariable5); // affiche [1, 2, 3, 4]`f`b

`B100`F9d9alert(maVariable6); // affiche [1, 2, 3, 4]`f`b

>>>Portée lexicale des variables

La `*`F33f`_`[portée lexicale`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Portée_lexicale]`_`f`* d'une variable est la partie d'un programme où la liaison entre son identifiant et sa donnée est valide. En JavaScript, la portée lexicale d'une variable peut être de deux types, selon le mot-clé utilisé pour la déclarer :

• `B100`F9d9var`f`b : au niveau de la `*fonction`* (ou de l'espace global) où elle est déclarée (comme en `F33f`_`[Python`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Python_(langage)]`_`f, `F33f`_`[Ruby`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Ruby]`_`f) ;

• `B100`F9d9let`f`b ou `B100`F9d9const`f`b (introduits dans ECMAScript 6) : au niveau du `*bloc`* où elle est déclarée (comme en `F33f`_`[C++`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=C++]`_`f, `F33f`_`[Java`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Java_(langage)]`_`f, `F33f`_`[C#`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=C_sharp]`_`f) — une fonction étant un bloc particulier.

Depuis le support de `B100`F9d9let`f`b par les navigateurs modernes, `B100`F9d9var`f`b ne doit plus être utilisé et son utilisation est considéré comme une mauvaise pratique`:cite-ref-29[`F5bf`_`[29`#cite-note-29]`_`f].

`B100`F9d9// 1. Déclaration dans un bloc`f`b

`B100`F9d9`f`b

`B100`F9d9if (true) { // début du bloc`f`b

`B100`F9d9 var maVariable1; // déclaration de la variable`f`b

`B100`F9d9 let maVariable2; // déclaration de la variable`f`b

`B100`F9d9 const maVariable3; // déclaration de la variable`f`b

`B100`F9d9} // fin du bloc mais pas de la portée de maVariable1`f`b

`B100`F9d9`f`b

`B100`F9d9alert(maVariable1); // ne soulève pas d'erreur`f`b

`B100`F9d9alert(maVariable2); // erreur : la variable est hors de sa portée`f`b

`B100`F9d9alert(maVariable3); // erreur : la variable est hors de sa portée`f`b

`B100`F9d9`f`b

`B100`F9d9// 2. Déclaration dans une fonction`f`b

`B100`F9d9`f`b

`B100`F9d9function maFunction() { // début de la fonction`f`b

`B100`F9d9 var maVariable4; // déclaration de la variable`f`b

`B100`F9d9 let maVariable5; // déclaration de la variable`f`b

`B100`F9d9 const maVariable6; // déclaration de la variable`f`b

`B100`F9d9} // fin de la fonction et de la portée des variables`f`b

`B100`F9d9`f`b

`B100`F9d9alert(maVariable4); // erreur : la variable est hors de sa portée`f`b

`B100`F9d9alert(maVariable5); // erreur : la variable est hors de sa portée`f`b

`B100`F9d9alert(maVariable6); // erreur : la variable est hors de sa portée`f`b

Une variable peut être affectée ou masquée par une fonction enfant de la fonction (ou de l'espace global) où elle est déclarée :

`B100`F9d9var maVariable1 = 0; // définition de la variable parente`f`b

`B100`F9d9`f`b

`B100`F9d9// 1. Affectation`f`b

`B100`F9d9`f`b

`B100`F9d9function maFonction1() { // fonction enfant`f`b

`B100`F9d9 maVariable1 = 1; // affectation de la variable parente`f`b

`B100`F9d9}`f`b

`B100`F9d9`f`b

`B100`F9d9alert(maVariable1); // affiche 0`f`b

`B100`F9d9maFonction1(); // affecte la variable parente`f`b

`B100`F9d9alert(maVariable1); // affiche 1`f`b

`B100`F9d9`f`b

`B100`F9d9// 2. Masquage`f`b

`B100`F9d9`f`b

`B100`F9d9var maVariable2 = 0; // définition de la variable parente`f`b

`B100`F9d9`f`b

`B100`F9d9function maFonction2() { // fonction enfant`f`b

`B100`F9d9 var maVariable2; // déclaration de la variable enfant masquant la variable parente`f`b

`B100`F9d9 maVariable2 = 1; // affectation de la variable enfant`f`b

`B100`F9d9}`f`b

`B100`F9d9`f`b

`B100`F9d9alert(maVariable2); // affiche 0`f`b

`B100`F9d9maFonction2();`f`b

`B100`F9d9alert(maVariable2); // affiche 0`f`b

>>>Déclaration des variables

En JavaScript, quel que soit le lieu de la déclaration d'une variable dans sa portée lexicale, la variable est `*créée`* au début de l'évaluation de sa portée lexicale.

Les variables déclarées avec le mot-clé `B100`F9d9var`f`b sont en plus `*pré-initialisées`* à la valeur `B100`F9d9undefined`f`b lors de leur création, et donc accessibles dès le début de leur portée lexicale. On parle de `*remontée de la variable`* (`*variable hoisting`* en anglais) car cela se passe comme si la déclaration de la variable était remontée au début de sa portée lexicale :

`B100`F9d9alert(maVariable); // affiche undefined`f`b

`B100`F9d9var maVariable = 0;`f`b

`B100`F9d9alert(maVariable); // affiche 0`f`b

Les variables déclarées avec le mot-clé `B100`F9d9let`f`b ou `B100`F9d9const`f`b (ECMAScript 6) ne sont pas pré-initialisées, et donc inaccessibles avant leur déclaration. Si une variable déclarée avec le mot-clé `B100`F9d9let`f`b ne possède pas d'initialiseur, elle est initialisée à la valeur `B100`F9d9undefined`f`b lors de l'évaluation de la déclaration, sinon elle est initialisée avec l'initialiseur lors de l'évaluation de la déclaration. Si une variable déclarée avec le mot-clé `B100`F9d9const`f`b ne possède pas d'initialiseur, une erreur est levée lors de l'évaluation de la déclaration, sinon elle est initialisée avec l'initialiseur lors de l'évaluation de la déclaration :

`B100`F9d9// 1. Avec initialiseur`f`b

`B100`F9d9`f`b

`B100`F9d9alert(maVariable1); // erreur : accès impossible avant l'initialisation`f`b

`B100`F9d9alert(maVariable2); // erreur : accès impossible avant l'initialisation`f`b

`B100`F9d9let maVariable1 = 5;`f`b

`B100`F9d9const maVariable2 = 8;`f`b

`B100`F9d9alert(maVariable1); // affiche 5`f`b

`B100`F9d9alert(maVariable2); // affiche 8`f`b

`B100`F9d9`f`b

`B100`F9d9// 2. Sans initialiseur`f`b

`B100`F9d9`f`b

`B100`F9d9alert(maVariable3); // erreur : accès impossible avant l'initialisation`f`b

`B100`F9d9alert(maVariable4); // erreur : accès impossible avant l'initialisation`f`b

`B100`F9d9let maVariable3;`f`b

`B100`F9d9const maVariable4; // erreur : initialisation manquante`f`b

`B100`F9d9alert(maVariable3); // affiche undefined`f`b

`B100`F9d9alert(maVariable4); // erreur : initialisation manquante`f`b

De plus, JavaScript autorise la redéclaration de la même variable dans sa portée lexicale, mais uniquement avec le mot-clé `B100`F9d9var`f`b :

`B100`F9d9var maVariable = 2;`f`b

`B100`F9d9var maVariable = 9;`f`b

>>>Variables globales

En JavaScript, il existe plusieurs façons de déclarer une `*variable globale`*, et certaines interagissent avec l'`*objet global`* (nommé `B100`F9d9window`f`b dans les navigateurs) :

`B100`F9d9var maVariable1 = 0; // propriété ou méthode de l'objet global qui ne peut pas être détruite par l'opérateur delete`f`b

`B100`F9d9let maVariable2 = 0; // pas une propriété ou méthode de l'objet global`f`b

`B100`F9d9const maVariable3 = 0; // pas une propriété ou méthode de l'objet global`f`b

`B100`F9d9maVariable4 = 0; // propriété ou méthode de l'objet global qui peut être détruite par l'opérateur delete`f`b

`B100`F9d9window.maVariable5 = 0; // propriété ou méthode de l'objet global qui peut être détruite par l'opérateur delete`f`b

`B100`F9d9this.maVariable6 = 0; // propriété ou méthode de l'objet global qui peut être détruite par l'opérateur delete`f`b

Une variable initialisée sans déclaration est traitée comme une `F33f`_`[variable globale`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Variable_globale]`_`f :

`B100`F9d9function maFonction() {`f`b

`B100`F9d9 maVariable = 5;`f`b

`B100`F9d9}`f`b

`B100`F9d9`f`b

`B100`F9d9maFonction();`f`b

`B100`F9d9alert(maVariable); // affiche 5`f`b

>>>Fonctions anonymes

Les `*`F33f`_`[fonctions anonymes`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Fonction_anonyme]`_`f`* sont, comme leur nom l'indique, des fonctions qui ne portent pas de nom :

`B100`F9d9setTimeout(function () {`f`b

`B100`F9d9 alert('Trois secondes se sont écoulées.');`f`b

`B100`F9d9}, 3000);`f`b

Celle-ci est donnée en paramètre à la fonction `B100`F9d9setTimeout`f`b, qui permet de définir une durée avant d'afficher le message.

>>>Fermetures lexicales

Un `*environnement lexical`* est l'ensemble des variables valides dans une partie du programme. Il est composé de l'environnement lexical `*interne`* (les `F33f`_`[variables locales`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Variable_locale]`_`f) et d'une référence à l'environnement lexical `*externe`* (les variables non locales).

Une `F33f`_`[fermeture lexicale`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Fermeture_(informatique)]`_`f (`*lexical closure`* en anglais) est une fonction accompagnée de son environnement lexical externe, c'est-à-dire de l'ensemble des variables non locales qu'elle a capturé, soit par `*valeur`* (conservation d'une copie de chaque donnée liée aux variables non locales), soit par `*référence`* (conservation d'une référence à chaque donnée liée aux variables non locales). Comme en JavaScript toutes les variables sont de type référence (cf. la section `F33f`_`[Liaison des identifiants`#liaison-des-identifiants]`_`f), JavaScript n'utilise que la capture par référence — ce qui correspond en `F33f`_`[C++ 11`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=C++11]`_`f à la syntaxe `B100`F9d9[&](…) { … };`f`b —, et la durée de vie des variables non locales capturées par une fonction est étendue à la durée de vie de la fonction — ce qui n'est pas le cas en C++ 11, quel que soit le type de capture :

`B100`F9d9function maFonction() {`f`b

`B100`F9d9 var maVariable = 4; // variable parente`f`b

`B100`F9d9`f`b

`B100`F9d9 return function () {`f`b

`B100`F9d9 alert(maVariable);`f`b

`B100`F9d9 }`f`b

`B100`F9d9}`f`b

`B100`F9d9`f`b

`B100`F9d9var maFermeture = maFonction(); // capture de la variable parente par référence`f`b

`B100`F9d9maFermeture(); // affiche 4`f`b

>>>Expressions de fonctions immédiatement invoquées

Jusqu'à ECMAScript 6, JavaScript ne proposait pas nativement de portée des variables au niveau des blocs (pas de mots-clé `B100`F9d9let`f`b ou `B100`F9d9const`f`b), ni de `F33f`_`[modules`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Module_(programmation)]`_`f. Pour éviter de polluer l'espace global, une méthode consistait à encapsuler son code dans une fonction pour s'appuyer sur la portée des variables qui a lieu au niveau des fonctions en JavaScript, puis à invoquer cette fonction juste après. Pour regrouper les deux étapes (définition de la fonction et invocation) et ne pas ajouter un nom de fonction supplémentaire dans l'espace global, le langage permet les `*expressions de fonctions immédiatement invoquées`* (EFII ; en anglais `*immediately-invoked function expressions`*, IIFE)`:cite-ref-30[`F5bf`_`[30`#cite-note-30]`_`f].

Plusieurs syntaxes sont possibles pour ce type d'expression, les plus répandues étant :

• `B100`F9d9`!(`!function (…) { … }(…)`!)`!;`f`b (syntaxe recommandée par `F33f`_`[Douglas Crockford`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Douglas_Crockford]`_`f pour sa lisibilité)`:cite-ref-31[`F5bf`_`[31`#cite-note-31]`_`f] ;

• `B100`F9d9`!(`!function (…) { … }`!)`!(…);`f`b

L'opérateur d'invocation de fonction `B100`F9d9()`f`b à la fin permet l'exécution immédiate de la fonction. Les parenthèses en gras indiquent à l'analyseur syntaxique qu'elles contiennent une expression, car en JavaScript les parenthèses ne peuvent pas contenir de déclaration. Autrement, dans la plupart des situations, le mot clé `B100`F9d9function`f`b est traité comme une déclaration de fonction, et pas comme une expression de fonction. Il existe d'autres façons pour forcer une expression de fonction :

• `B100`F9d9!function (…) { … }(…);`f`b

• `B100`F9d9~function (…) { … }(…);`f`b

• `B100`F9d9-function (…) { … }(…);`f`b

• `B100`F9d9+function (…) { … }(…);`f`b

Dans les contextes où une expression est attendue il n'est pas nécessaire d'utiliser les parenthèses en gras :

• `B100`F9d9var maVariable = function (…) { … }(…);`f`b

• `B100`F9d9true && function (…) { … }(…);`f`b

• `B100`F9d90, function (…) { … }(…);`f`b

Une utilisation importante des expressions de fonctions immédiatement invoquées est pour la création de modules. Les modules permettent à la fois de rassembler des propriétés et des méthodes dans un espace de nom et de rendre certains membres privés :

`B100`F9d9var compteur = (function () {`f`b

`B100`F9d9 var i = 0; // propriété privée`f`b

`B100`F9d9`f`b

`B100`F9d9 return { // méthodes publiques`f`b

`B100`F9d9 obtenir: function () {`f`b

`B100`F9d9 alert(i);`f`b

`B100`F9d9 },`f`b

`B100`F9d9 mettre: function (valeur) {`f`b

`B100`F9d9 i = valeur;`f`b

`B100`F9d9 },`f`b

`B100`F9d9 incrementer: function () {`f`b

`B100`F9d9 alert(++i);`f`b

`B100`F9d9 }`f`b

`B100`F9d9 };`f`b

`B100`F9d9})(); // module`f`b

`B100`F9d9`f`b

`B100`F9d9compteur.obtenir(); // affiche 0`f`b

`B100`F9d9compteur.mettre(6);`f`b

`B100`F9d9compteur.incrementer(); // affiche 7`f`b

`B100`F9d9compteur.incrementer(); // affiche 8`f`b

`B100`F9d9compteur.incrementer(); // affiche 9`f`b

>>>Prototypes

Les `F33f`_`[prototypes`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Programmation_orientée_prototype]`_`f sont des objets utilisés lors d'un échec de résolution de nom. Ce mécanisme est un type d'héritage : l'héritage par prototype. En JavaScript, tout objet possède un prototype, accessible via la méthode `B100`F9d9Object.getPrototypeOf`f`b (ou via la propriété historique `B100`F9d9__proto__`f`b standardisée dans ECMAScript 6 pour assurer la compatibilité entre les navigateurs mais non recommandée). De plus, l'opérateur `B100`F9d9new`f`b permet de transformer l'invocation d'une fonction constructeur en un objet (instanciation) dont le prototype est égal à la propriété `B100`F9d9prototype`f`b de la fonction constructeur :

`B100`F9d9function MonConstructeur() {`f`b

`B100`F9d9 this.maPropriete1 = 3;`f`b

`B100`F9d9}`f`b

`B100`F9d9`f`b

`B100`F9d9const monInstance = new MonConstructeur();`f`b

`B100`F9d9alert(monInstance.maPropriete1); // affiche 3`f`b

`B100`F9d9alert(Object.getPrototypeOf(monInstance) === MonConstructeur.prototype); // affiche true`f`b

`B100`F9d9MonConstructeur.prototype.maPropriete2 = 5;`f`b

`B100`F9d9alert(monInstance.maPropriete2); // affiche 5`f`b

Toute instance de `B100`F9d9MonConstructeur`f`b (`B100`F9d9monInstance`f`b ici) possède un prototype égal à `B100`F9d9MonConstructeur.prototype`f`b. Lors de l'utilisation d'une propriété ou d'une méthode d'une instance de `B100`F9d9MonConstructeur`f`b (`B100`F9d9monInstance.maPropriete1`f`b et `B100`F9d9monInstance.maPropriete2`f`b ici), si l'instance ne possède pas la propriété ou la méthode recherchée, la recherche se poursuit dans le prototype de l'instance (`B100`F9d9MonConstructeur.prototype`f`b ici). Si la recherche échoue aussi avec cet objet, la recherche se poursuit dans le prototype de cet objet, et ainsi de suite jusqu'à arriver à la première fonction constructeur. Si la recherche échoue encore, cette première fonction constructeur étant une fonction donc une instance de la fonction constructeur `B100`F9d9Function`f`b du langage, la recherche se poursuit dans son prototype qui est égal à `B100`F9d9Function.prototype`f`b. Si la recherche échoue à nouveau, `B100`F9d9Function.prototype`f`b étant un objet donc une instance de la fonction constructeur `B100`F9d9Object`f`b du langage, la recherche se poursuit dans son prototype qui est égal à `B100`F9d9Object.prototype`f`b. Si la recherche échoue cette fois, comme le prototype de `B100`F9d9Object.prototype`f`b est égal à `B100`F9d9null`f`b, la recherche s'arrête et JavaScript génère une erreur de résolution de nom. Ce mécanisme de recherche parcourt ce qu'on appelle la `*chaîne de prototypes`*.

Le code de l'opérateur `B100`F9d9instanceOf`f`b illustre bien ce mécanisme. `B100`F9d9A instanceOf B`f`b (ou de manière équivalente : `B100`F9d9instanceOf.call(A, B)`f`b) renvoie `B100`F9d9true`f`b si `B100`F9d9A`f`b est une instance de `B100`F9d9B`f`b, c'est-à-dire si `B100`F9d9B.prototype`f`b est trouvé dans le chaîne de prototypes de `B100`F9d9A`f`b, et `B100`F9d9false`f`b sinon :

`B100`F9d9function instanceOf(f) {`f`b

`B100`F9d9 let o = this;`f`b

`B100`F9d9`f`b

`B100`F9d9 while (o !== null) {`f`b

`B100`F9d9 o = Object.getPrototypeOf(o);`f`b

`B100`F9d9`f`b

`B100`F9d9 if (o === f.prototype) {`f`b

`B100`F9d9 return true;`f`b

`B100`F9d9 }`f`b

`B100`F9d9`f`b

`B100`F9d9 return false;`f`b

`B100`F9d9}`f`b

Par ailleurs, la méthode `B100`F9d9Object.create`f`b introduite dans ECMAScript 5 permet d'éviter d'utiliser directement les fonctions constructeurs, leurs propriétés `B100`F9d9prototype`f`b et l'opérateur `B100`F9d9new`f`b, pour ne travailler qu'avec des objets. L'utilisation de cette méthode simplifie grandement la complexité du code et est donc recommandée. La méthode `B100`F9d9Object.create`f`b est définie par

`B100`F9d9if (typeof Object.create !== 'function') {`f`b

`B100`F9d9 Object.create = function (o) {`f`b

`B100`F9d9 function F() {}`f`b

`B100`F9d9 F.prototype = o;`f`b

`B100`F9d9 return new F();`f`b

`B100`F9d9 };`f`b

`B100`F9d9}`f`b

L'exemple précédent peut alors être réécrit

`B100`F9d9const MonObjet = {`f`b

`B100`F9d9 function initialiser() {`f`b

`B100`F9d9 this.maPropriete1 = 3;`f`b

`B100`F9d9 }`f`b

`B100`F9d9}`f`b

`B100`F9d9`f`b

`B100`F9d9const monInstance = Object.create(MonObjet);`f`b

`B100`F9d9monInstance.initialiser();`f`b

`B100`F9d9alert(monInstance.maPropriete1); // affiche 3`f`b

`B100`F9d9MonObjet.maPropriete2 = 5;`f`b

`B100`F9d9alert(monInstance.maPropriete2); // affiche 5`f`b

>>>Séparation des instructions

En `F33f`_`[C`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=C_(langage)]`_`f, chaque instruction se termine par un `F33f`_`[point-virgule`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Point-virgule]`_`f. Cette pratique a fait du point-virgule une obligation dans de nombreux langages inspirés de la syntaxe du C.

JavaScript est plus souple, permettant à une `F33f`_`[fin de ligne`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Fin_de_ligne]`_`f de marquer implicitement la fin d'une instruction. Le but est de faciliter l'usage du langage aux personnes inexpérimentées en `F33f`_`[programmation informatique`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Programmation_informatique]`_`f. Mais cette souplesse introduit des effets inattendus`:cite-ref-32[`F5bf`_`[32`#cite-note-32]`_`f] :

`B100`F9d9return`f`b

`B100`F9d9 true;`f`b

Le parseur comprend cela comme deux instructions :

`B100`F9d9return;`f`b

`B100`F9d9true;`f`b

Les expressions de fonctions immédiatement invoquées lorsque le programmeur s'appuie sur les fins d'instruction implicites rencontrent également ce genre de problème avec l'usage des parenthèses :

`B100`F9d9maVariable1 = maVariable2 + maVariable3`f`b

`B100`F9d9`f`b

`B100`F9d9(function () {`f`b

`B100`F9d9 // code`f`b

`B100`F9d9})()`f`b

est traité comme

`B100`F9d9maVariable1 = maVariable2 + maVariable3(function () { /* code */ })();`f`b

Les ouvrages de programmation avancés en JavaScript mettent en garde contre les effets inattendus de la déduction automatique de fin d'instruction et conseillent d'écrire un point-virgule à la fin de chaque instruction, ce qui n'empêche pas les surprises lorsqu'on oublie le point-virgule, d'autant plus quand la compression du code impose le retrait des retours chariot.

>>Annexes

>>>Articles connexes

• `F33f`_`[Syntaxe JavaScript`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Syntaxe_JavaScript]`_`f

• `F33f`_`[Moteur JavaScript`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Moteur_JavaScript]`_`f

• `F33f`_`[Spécification de JavaScript`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Spécification_de_JavaScript]`_`f

• Sécurité du navigateur (en)

• `F33f`_`[jQuery`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=JQuery]`_`f

• `F33f`_`[DataTables`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=DataTables]`_`f

• `F33f`_`[TypeScript`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=TypeScript]`_`f

>>>Liens externes

• (en) Standard ECMA-262, `*ECMAScript 2016 Language Specification`*

• Mozilla Developer Center - JavaScript

• (en) Microsoft MSDN - JScript

• (en) Exemples d'utilisation avancée du langage JavaScript

• Open Directory - JavaScript

• `*JavaScript éloquent, Une introduction au langage de programmation JavaScript et à la programmation en général.`*

• (en) JSFiddle pour tester vos codes

• JavaScript obfuscator

• Javascript Deobfuscator

>>>Notes et références

`:cite-note-wikidata-fdaa92a1fc5308e94e5ed782a2024ab0bbc4c072-1`!1.`! « ECMAScript® 2024 Language Specification », juin 2024 (consulté le 30 août 2024)

`:cite-note-wikidata-6351048ad5638805e5935d8ba81b639a34072b65-2`!2.`! « ECMAScript® 2025 Language Specification », 27 mars 2024 (consulté le 17 avril 2024)

`:cite-note-3`!3.`! `F33f`_`[Douglas Crockford`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Douglas_Crockford]`_`f, dans une conférence à `F33f`_`[Yahoo!`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Yahoo!]`_`f Crockford on JavaScript - Chapter 2: And Then There Was JavaScript, se limite à Java, Scheme et Self comme influence direct de JavaScript

`:cite-note-4`!4.`! `F0af`_`[↑`#cite-ref-4]`_`f `:flanagan`a`:david-flanagan`aDavid Flanagan, JavaScript : The definitive guide, 6e éd., p. 1 « JavaScript is part of the triad of technologies that all Web developers must learn: HTML to specify the content of web pages, CSS to specify the presentation of web pages, and JavaScript to specify the behaviour of web pages. »

`:cite-note-deployedstats-5`!5.`! `F0af`_`[↑`#cite-ref-deployedstats-5-0]`_`f (en) « Usage Statistics of JavaScript for Websites, March 2018 », sur w3techs.com (consulté le 3 octobre 2018)

`:cite-note-6`!6.`! `F0af`_`[↑`#cite-ref-6]`_`f (en) « An Introduction to JavaScript », sur javascript.info (consulté le 20 juillet 2020)

`:cite-note-7`!7.`! `F0af`_`[↑`#cite-ref-7]`_`f (en) http://wiki.commonjs.org/wiki/CommonJS

`:cite-note-8`!8.`! `F0af`_`[↑`#cite-ref-8]`_`f `:foundation`a`:node-js-foundation`a(en) Node.js Foundation, « Node.js », sur Node.js (consulté le 5 août 2017)

`:cite-note-9`!9.`! `F0af`_`[↑`#cite-ref-9]`_`f `:tung`a`:liam-tung`a(en) Liam Tung, « Deno 1.0: Node.js makers have new JavaScript runtime for TypeScript programming language », sur ZDNet (consulté le 20 juillet 2020)

`:cite-note-10`!10.`! `F0af`_`[↑`#cite-ref-10]`_`f « nodejs », sur nodejs.org (consulté le 5 mars 2024)

`:cite-note-11`!11.`! `F0af`_`[↑`#cite-ref-11]`_`f TechVision: Innovators of the Net: Brendan Eich and JavaScript

`:cite-note-newsrelease67-12`!12.`! `F0af`_`[↑`#cite-ref-newsrelease67-12-0]`_`f (en) NETSCAPE AND SUN ANNOUNCE JAVASCRIPT, THE OPEN, CROSS-PLATFORM OBJECT SCRIPTING LANGUAGE FOR ENTERPRISE NETWORKS AND THE INTERNET

`:cite-note-13`!13.`! `F0af`_`[↑`#cite-ref-13]`_`f (en) « Trademark Status & Document Retrieval », sur tsdr.uspto.gov (consulté le 28 juin 2018)

`:cite-note-14`!14.`! `F0af`_`[↑`#cite-ref-14]`_`f « Sun Trademarks », 28 mai 2010 (version du 28 mai 2010 sur `*`F33f`_`[Internet Archive`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Internet_Archive]`_`f`*)

`:cite-note-15`!15.`! `F0af`_`[↑`#cite-ref-15]`_`f `:1997`a« U.S. Trademark Serial No. 75026640 » [archive du 13 juillet 2021], sur uspto.gov, `F33f`_`[United States Patent and Trademark Office`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=United_States_Patent_and_Trademark_Office]`_`f, 6 mai 1997 (consulté le 8 mai 2021)

`:cite-note-16`!16.`! `F0af`_`[↑`#cite-ref-16]`_`f « Notices Légales » [archive du 5 juin 2021], sur oracle.com, `F33f`_`[Oracle Corporation`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Oracle_Corporation]`_`f (consulté le 8 mai 2021)

`:cite-note-17`!17.`! `F0af`_`[↑`#cite-ref-17]`_`f `:2009`a« Oracle rachète Sun pour 7,4 milliards de dollars », `*Les Échos`*, 21 avril 2009

`:cite-note-18`!18.`! `F0af`_`[↑`#cite-ref-18]`_`f `:canh2010`a`:tran-canh2010`a(en-US) Tran Canh, « cdnhub.io », sur Technologizer by Harry McCracken, 16 septembre 2010 (consulté le 10 avril 2024)

`:cite-note-19`!19.`! `F0af`_`[↑`#cite-ref-19]`_`f « The secret history behind the success of npm and Node », sur www.theserverside.com (consulté le 10 avril 2024)

`:cite-note-20`!20.`! `F0af`_`[↑`#cite-ref-20]`_`f [1]

`:cite-note-21`!21.`! `F0af`_`[↑`#cite-ref-21]`_`f « Standard ECMA-262 », sur www.ecma-international.org (consulté le 2 octobre 2019)

`:cite-note-22`!22.`! `F0af`_`[↑`#cite-ref-22]`_`f « Making JavaScript Safe for Advertising », ADsafe (consulté le 26 mai 2013)

`:cite-note-23`!23.`! `F0af`_`[↑`#cite-ref-23]`_`f « Secure ECMA Script (SES) », Code.google.com (consulté le 26 mai 2013)

`:cite-note-24`!24.`! `F0af`_`[↑`#cite-ref-24]`_`f « Why is console.log() considered better than alert()? », sur stackoverflow.com (consulté le 5 août 2017)

`:cite-note-25`!25.`! `F0af`_`[↑`#cite-ref-25]`_`f (en-US) « Window », sur Mozilla Developer Network (consulté le 5 août 2017)

`:cite-note-26`!26.`! `F0af`_`[↑`#cite-ref-26]`_`f (en) « Global Objects | Node.js v8.2.1 Documentation », sur nodejs.org (consulté le 5 août 2017)

`:cite-note-27`!27.`! `F0af`_`[↑`#cite-ref-27]`_`f (en) « IEBlog », sur msdn.com (consulté le 29 septembre 2020).

`:cite-note-28`!28.`! `F0af`_`[↑`#cite-ref-28]`_`f Voir Introduction au shell JavaScript

`:cite-note-29`!29.`! `F0af`_`[↑`#cite-ref-29]`_`f `:2023`a(en-US) « Storing the information you need — Variables - Learn web development | MDN », sur developer.mozilla.org, 9 mai 2023 (consulté le 22 juin 2023)

`:cite-note-30`!30.`! `F0af`_`[↑`#cite-ref-30]`_`f `:alman2010`a`:ben-alman2010`a(en) Ben Alman, « Immediately-Invoked Function Expression (IIFE) », sur benalman.com, 15 novembre 2010 (consulté le 14 mai 2016)

`:cite-note-31`!31.`! `F0af`_`[↑`#cite-ref-31]`_`f `:crockford`a`:douglas-crockford`a(en) Douglas Crockford, « Code Conventions for the JavaScript Programming Language », sur javascript.crockford.com (consulté le 14 mai 2016)

`:cite-note-32`!32.`! `F0af`_`[↑`#cite-ref-32]`_`f Cet exemple est donné page 25 par : `*JavaScript - The Definitive Guide`*, Fourth Edition, David Flanagan, éditions `F33f`_`[O'Reilly Media`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=O'Reilly_Media]`_`f, Sebastopol, Californie.

• Portail de la programmation informatique

`c`F0af`_`[↑ Back to top`#top]`_`f`a